<template>
    <div class="topo-template-wrapper">
        <!-- <Alert type="warning" show-icon>
            <p>提示：</p>
            <p>1. 本步骤提供模板生成功能，操作步骤：进入拓扑编辑页面（绘制拓扑）> 生成工程模板</p>
            <p>2. 若拓扑结构有修改，请在编辑后重新生成模板</p>
            <p>3. 重新生成的模板将会替换原有模板</p>
        </Alert> -->
        <template v-if="onlyGenerateTemplate">
            <WarningTip
                :width="300"
                placement="left"
                content="保存科研前请确认科研环境和接入机器已配置完毕，保存科研将替换科研模板信息"
            ></WarningTip>
            <Button type="primary" @click="createProjectTemplate" :disabled="!proId"
                >保存科研</Button
            >
        </template>
        <template v-else>
            <Button type="primary" @click="createTop" style="margin-right: 6px;">编辑拓扑</Button>
            <Button type="primary" @click="createProjectTemplate" :disabled="!proId"
                >生成工程模板</Button
            >
            <WarningTip style="display: inline-block;">
                <p>提示：</p>
                <p>
                    1. 本步骤提供模板生成功能，操作步骤：进入拓扑编辑页面（绘制拓扑）> 生成工程模板
                </p>
                <p>2. 若拓扑结构有修改，请在编辑后重新生成模板</p>
                <p>3. 重新生成的模板将会替换原有模板</p>
            </WarningTip>
        </template>
    </div>
</template>
<script>
import { queryProjectstatus, queryNetworkList,creatBlankPro } from '../../api/deploy.js';
import { updateContent } from '../../api/content.js';
import { createTemplate } from '@/api/proTemplate';
export default {
    name: 'TopoTemplate',
    inject: ['detailParent'],
    props: {
        onlyGenerateTemplate: {
            type: Boolean,
            default: false
        }
    },
    computed: {
        proId() {
            return this.detailParent.contentDetail.projectId;
        },
        contentId() {
            return this.detailParent.contentDetail.id;
        },
        contentName() {
            return this.detailParent.contentDetail.name;
        },
        tmplId() {
            return this.detailParent.contentDetail.tmplId;
        }
    },
    mounted() {},
    methods: {
        // 创建拓扑
        async createTop() {
            if (!this.proId) {
                // 没有工程
                this.createProject(this.tmplId); // 创建工程并跳转
            } else {
                // 存在工程
                let status = await this.getProjectDetails(this.proId);
                if (status !== 1) {
                    // 查看工程ID是否还存在，不存在重新创建并绑定，存在直接跳转
                    this.createProject(this.tmplId);
                } else {
                    window.openTrain(
                        `/14-NetTopology/TopoEdit.html?project=${this.contentDetail.projectId}&networkid=${this.contentDetail.networkId}`
                    );
                    // window.openTrain(
                    //     `http://172.172.100.1/ky-topologyProject/index.html#/topologyDisplay/topologys?projectId=${this.proId}&ecId=${this.contentId}&ecName=${this.contentName}`
                    // );
                }
            }
        },
        // 查询工程是否存在
        getProjectDetails(id) {
            return new Promise((resolve, reject) => {
                queryProjectstatus(id)
                    .then((data) => {
                        // 存在工程，允许跳转
                        if (
                            data.code == 1 &&
                            data.data.items.length > 0 &&
                            ![4, 17].includes(data.data.items[0].status)
                        ) {
                            resolve(1);
                        } else {
                            resolve(0);
                        }
                        resolve(1);
                    })
                    .catch((error) => {
                        resolve(0);
                    });
            });
        },
        // 创建工程，并绑定工程与案例关联关系，关系绑定完成后，跳转至拓扑图页面
        createProject(tmplId, notNeedJump, tmplName) {
            return new Promise((resolve) => {
                creatBlankPro(
                    tmplId ? tmplId : '',
                    {
                        mode: 'complete',
                        name: this.contentName,
                        quotaTypeId: '2',
                        trainId: 0,
                        type: 'normal'
                    },
                    'complete'
                )
                    .then(data => {
                        let { code, message, attribute } = data;
                        if (![1, 2].includes(code)) {
                            // 成功或导入中均不需要报错
                            this.$Message.warning(message);
                            return;
                        }
                        let result = attribute.result;
                        // 工程创建完毕，绑定工程与案例关联关系
                        data = {
                            projectId: result.id
                        };
                        updateContent(this.contentId, data)
                            .then(({ code, message }) => {
                                if (code !== 1) {
                                    this.$Message.warning(message);
                                    return;
                                }
                                this.detailParent.contentDetail.projectId = result.id;
                                if (tmplName) {
                                    // 没值不修改这个值
                                    this.$set(this.caseDetail, 'tmplName', tmplName);
                                }
                                if (notNeedJump) {
                                    // 不需要跳转页面，不需要跳转并提示信息
                                    if (this.currentStep !== 3) {
                                        this.currentStep += 1;
                                    }
                                    return;
                                }
                                this.$Message.success('正在跳转至拓扑编辑页面，请确保窗口未被拦截');
                                window.openTrain(
                                    `/jjzzTopo/index.html#/ProjectViews?projectId=${result.id}`
                                );
                            })
                            .catch(() => {
                                this.$Message.error('修改案例工程异常');
                            })
                            .finally(() => {
                                resolve();
                            });
                    })
                    .catch(() => {
                        this.$Message.error('创建拓扑图异常');
                        resolve();
                    });
            });
        },
        // 判断工程中是否存在节点
        getHasNode() {
            return new Promise((resolve) => {
                queryProjectstatus(this.proId)
                    .then(({ code, attribute = {} }) => {
                        if (code === 1) {
                            let network = attribute.network || {};
                            if (network.id) {
                                queryNetworkList(this.proId, network.id)
                                    .then(({ code, attribute = {} }) => {
                                        if (
                                            code === 1 &&
                                            attribute.editorStage &&
                                            attribute.editorStage.deviceNum
                                        ) {
                                            this.hasNode = true;
                                            resolve();
                                        } else {
                                            resolve();
                                        }
                                    })
                                    .catch(() => {
                                        resolve();
                                    });
                            } else {
                                resolve();
                            }
                        } else {
                            resolve();
                        }
                    })
                    .catch(() => {
                        resolve();
                    });
            });
        },
        // 创建工程模板
        async createProjectTemplate() {
            await this.getHasNode();
            if (this.hasNode) {
                createTemplate({
                    description: '',
                    markType: '',
                    name: this.contentName,
                    picUrl: '',
                    projectId: this.proId,
                    visibility: 'share'
                })
                    .then(({ code, data, message }) => {
                        if (code !== 1) {
                            this.$Message.warning(message);
                            return;
                        }
                        // 模板创建完毕，绑定工程与模板关联关系
                        let obj = {
                            id: data,
                            name: this.contentName // 这种方式创建的工程模板名称，会与科研名称保持一致
                        };
                        this.$emit('on-success', obj);
                    })
                    .catch(() => {
                        this.$Message.error('生成模板异常');
                    });
            } else {
                this.$Message.warning('还没有进行拓扑编辑，请先进行拓扑编辑');
            }
        }
    }
};
</script>
<style scoped></style>
